package com.jxtc.enterprise.tenant.service;

import com.alibaba.fastjson.JSONObject;
import com.jxtc.enterprise.common.config.AppAuthConfig;
import com.jxtc.enterprise.common.entity.DeliveryRider;
import com.jxtc.enterprise.common.enums.SupplyModeEnum;
import com.jxtc.enterprise.common.exception.HttpClientException;
import com.jxtc.enterprise.common.exception.InsertFailureException;
import com.jxtc.enterprise.common.mapper.RiderMapper;
import com.jxtc.enterprise.common.utils.HttpClientUtil;
import com.jxtc.enterprise.common.utils.Result;
import com.jxtc.enterprise.tenant.vo.req.RiderCreateRemoteReqVo;
import com.jxtc.enterprise.tenant.vo.req.RiderSupplyModeUpdateReqVo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@RequiredArgsConstructor
@Slf4j
public class TenantRiderManageService {

    private final RiderMapper riderMapper;
    private final AppAuthConfig appAuthConfig;
    private final HttpClientUtil httpClientUtil;


    @Transactional(rollbackFor = InsertFailureException.class)
    public void addNewDeliveryRider(DeliveryRider rider, String tenantId, int verifyFlag) {
        int insertCount = riderMapper.insert(rider);
        if (insertCount != 1) {
            // 新增配送员失败时，向前端返回错误提示信息，并触发回滚
            log.error("/addNewDeliveryRider, 配送员信息新增失败, insertCount: {}, tenantId: {}, deliverRiderEntity: {}", insertCount, tenantId, JSONObject.toJSONString(rider));
            throw new InsertFailureException("配送员信息新增失败，请稍后重试");
        }

        // 获取新增后的配送员 ID
        String riderId = rider.getId();

        // 根据 verifyFlag 判断配送员信息是否存在，如果配送员信息不存在，则调用认证服务新增配送员信息
        // 最后新增配送员信息的原因：如果调用远程服务后出现错误，可以触发回滚来保证数据一致性
        if (verifyFlag == 2) {
            // 如果配送员信息不存在，则调用认证服务新增配送员信息
            String host = appAuthConfig.getUrl();
            String url = host + "/jxtc/customer/auth/riderAuth/register";
            // 构建请求体
            RiderCreateRemoteReqVo requestBody = buildRiderCreateRemoteReqVo(rider, riderId);
            try {
                // 向认证服务发送 HTTP 请求
                Result<?> result = httpClientUtil.post(url, null, requestBody, new ParameterizedTypeReference<Result<Void>>() {
                });
                // 如果认证服务未返回响应结果过状态码不为 200，则记录日志并向前端返回错误提示信息
                if (result == null || result.getCode() != 200) {
                    log.error("/addStore, 认证服务新增配送员信息失败, tenantId: {}, riderId: {}, requestBody: {}, result: {}",
                            tenantId, riderId, JSONObject.toJSONString(requestBody), JSONObject.toJSONString(result));
                    throw new InsertFailureException("新增配送员信息失败");
                }
            } catch (HttpClientException e) {
                // 认证服务异常时，返回错误提示信息并记录日志
                log.error("/addStore, 认证服务新增配送员信息失败, 服务异常: {}", e.getMessage());
                throw new InsertFailureException("新增配送员信息失败");
            }
        } else if (verifyFlag == 1) {
            // 如果配送员信息存在，则调用认证服务更新配送员的供餐模式
            String host = appAuthConfig.getUrl();
            String url = host + "/jxtc/customer/auth/merchantManage/editMerchantSupplyMode";
            // 构建请求体
            RiderSupplyModeUpdateReqVo riderSupplyModeUpdateReqVo = new RiderSupplyModeUpdateReqVo();
            // 更新配送员供餐模式时，需要将当前系统的供餐模式添加到配送员表中
            riderSupplyModeUpdateReqVo.setSupplyMode(SupplyModeEnum.ENTERPRISE.getValue());
            riderSupplyModeUpdateReqVo.setEnterpriseModeRiderId(riderId);
            riderSupplyModeUpdateReqVo.setPhone(rider.getPhone());
            try {
                // 向认证服务发送 HTTP 请求
                Result<?> result = httpClientUtil.post(url, null, riderSupplyModeUpdateReqVo, new ParameterizedTypeReference<Result<Void>>() {
                });
                // 如果认证服务未返回响应结果过状态码不为 200，则记录日志并向前端返回错误提示信息
                if (result == null || result.getCode() != 200) {
                    log.error("/addStore, 认证服务更新配送员供餐模式失败, tenantId: {}, riderId: {}, riderSupplyModeUpdateReqVo: {}, result: {}",
                            tenantId, riderId, JSONObject.toJSONString(riderSupplyModeUpdateReqVo), JSONObject.toJSONString(result));
                    throw new InsertFailureException("更新配送员供餐模式失败");
                }
            } catch (HttpClientException e) {
                // 认证服务异常时，返回错误提示信息并记录日志
                log.error("/addStore, 认证服务更新配送员供餐模式失败, 服务异常: {}", e.getMessage());
                throw new InsertFailureException("更新配送员供餐模式失败");
            }
        }
    }

    private static RiderCreateRemoteReqVo buildRiderCreateRemoteReqVo(DeliveryRider reqVo, String riderId) {
        RiderCreateRemoteReqVo riderCreateRemoteReqVo = new RiderCreateRemoteReqVo();
        riderCreateRemoteReqVo.setPhone(reqVo.getPhone());
        riderCreateRemoteReqVo.setName(reqVo.getName());
        riderCreateRemoteReqVo.setPassword(reqVo.getPassword());
        // 新增配送员信息时，以发起请求的后端系统为供餐模式即可，当前为：公司团餐
        riderCreateRemoteReqVo.setSupplyMode(SupplyModeEnum.ENTERPRISE.getValue());
        riderCreateRemoteReqVo.setEnterpriseModeRiderId(riderId);
        return riderCreateRemoteReqVo;
    }

    /**
     * 骑手可接单状态，比如某个骑手有事临时请假3天，则可以将该骑手状态切换为 不可接单
     * 1：可接单，配送
     * 2：不可接单，不可配送
     *
     * @param statusCode 状态编码，1,2
     * @return 状态中文名
     */
    public String convertRiderStatusCodeToNameCn(int statusCode) {

        switch (statusCode) {
            case 1:
                return "可配送";
            case 2:
                return "不可配送";
            default:
                return "未知类型 " + statusCode;
        }
    }

    /**
     * 当前骑手类型分为如下两类，db表中保存的是类型编码，返回给前端页面时，需要转换成类型名称
     * 1：专属骑手
     * 2：共享骑手
     *
     * @param typeCode 类型编码，1,2
     * @return 类型中文名
     */
    public String convertRiderTypeCodeToNameCn(int typeCode) {

        switch (typeCode) {
            case 1:
                return "专属骑手";
            case 2:
                return "共享骑手";
            default:
                return "未知类型 " + typeCode;
        }
    }


}
